#!/usr/bin/python
# -*- coding: utf-8 -*-

from class_segment import *
import math

def one_is_in(s1,e1,s2,e2) :
  return (is_in(s1,e1,s2,e2) or is_in(s2,e2,s1,e1))

def is_in(s1,e1,s2,e2) :
  return (s1 <= s2 and e1 >= e2)

def is_overlap(s1,e1,s2,e2) :
  surface = (e1 - s1) + (e2 - s2)
  min_inter = min((e1-s1),(e2-s2))
  l = [s1,e1,s2,e2]
  l.sort()
  etal = l[3] - l[0]
  interval_inter = len_interval_inter(s1,e1,s2,e2)
  return (etal < surface and interval_inter < min_inter )

#Donne la longueur de l'intersection entre [s1,e1] et [s2,e2]

def len_interval_inter(s1,e1,s2,e2) :
  l = [s1,e1,s2,e2]
  l.sort()
  return l[2]-l[1]

#à partir d'un dico à trou et d'une base vectorielle
#donne le vecteur complet équivalent (res[i] = val)

def repartition_bloc2vect(rep,list_base) :
  res = []
  for i in list_base :
    if i in rep :
      res.append(rep[i])
    else :
      res.append(0)
  return res

#Calcul RV : rapport de vraissemblance

def xlogx(x) :
  if(x == 0) :
    res = 0
  else :
    res = x * math.log(x)
  return res

def xlogy(x,y) :
  if(x == 0) :
    res = 0
  else :
    res = x * math.log(y)
  return res

def get_sp(a,b,c,d) :
  n = a + b + c + d
  res = xlogx(a) + xlogx(b) + xlogx(c) + xlogx(d) + xlogx(n)
  return res

def get_sl(a,b,c,d) :
  ac = a + c
  bd = b + d
  ab = a + b
  cd = c + d
  res = xlogx(ac) + xlogx(bd) + xlogx(ab) + xlogx(cd)
  return res

def get_table_contingence(v1,v2) :
  assert(len(v1) == len(v2))
  m00 = m10 = m11 = m01 = 0.
  l = len(v1)
  for i in xrange(0,l) :
    if v1[i] > 0 :
      if v2[i] > 0 :
        m11 += 1
      else :
        m10 +=1      
    else :
      if v2[i] > 0 :
        m01 += 1
      else :
        m00 +=1      
  res = [m00, m10, m11, m01]
  return res

def get_rv(t) :
  sl = get_sl(t[0],t[1],t[2],t[3])
  sp = get_sp(t[0],t[1],t[2],t[3])
  res = 2 *(sp-sl)
  return res

#cosinus

def get_angle(v1,v2) :
  assert(len(v1) == len(v2))
  l = len(v1)
  up = n1 = n2 = 0.0
  for i in xrange(l) :
    up += v1[i] * v2[i]
    n1 += v1[i] * v1[i]
    n2 += v2[i] * v2[i]
  return up / math.sqrt(n1*n2)

#information mutuelle

def count_occ(vect) :
  cpt = 0.
  for val in vect :
    if val > 0 :
      cpt += 1.
  return cpt

def count_occ_conjointe(v1,v2) :
  l = len(v1)
  cpt = 0.
  for i in xrange(0,l) :
    if(v1[i] > 0 and v2[i] > 0) :
      cpt += 1
  return cpt

def get_im(v1,v2) :
  assert(len(v1) == len(v2))
  l = float(len(v1))
  p12 = count_occ_conjointe(v1,v2) / l
  p1 = count_occ(v1) / l
  p2 = count_occ(v2) / l
  p1p2 = p1*p2
  print "%f/%f" %(p12,p1p2)#p1,p2,p12,p1p2, rapport
  if(p12 == 0 or p1 == 0 or p2 == 0) :
    print "!"
    return 0.
  return math.log(p12 / (p1*p2),2)

def table_contingence(v1,v2) :
  assert(v1 == v2)
